home *** CD-ROM | disk | FTP | other *** search
/ Info-Mac 3 / Info_Mac_1994-01.iso / Development / Source / Jotto ][ 1.0 Source / Jotto ][ ƒ / MSG Shell ƒ / msg menus.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-12-11  |  5.8 KB  |  263 lines  |  [TEXT/KAHL]
  1. /**********************************************************************\
  2.  
  3. File:        msg menus.c
  4.  
  5. Purpose:    This module handles menu selections, including selection
  6.             of dimmed menu items (hehe).
  7.  
  8.  
  9. Jotto ][ -=- a simple word game, revisited
  10. Copyright (C) 1993 Mark Pilgrim
  11.  
  12. This program is free software; you can redistribute it and/or modify
  13. it under the terms of the GNU General Public License as published by
  14. the Free Software Foundation; either version 2 of the License, or
  15. (at your option) any later version.
  16.  
  17. This program is distributed in the hope that it will be useful,
  18. but WITHOUT ANY WARRANTY; without even the implied warranty of
  19. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20. GNU General Public License for more details.
  21.  
  22. You should have received a copy of the GNU General Public License
  23. along with this program in a file named "GNU General Public License".
  24. If not, write to the Free Software Foundation, 675 Mass Ave,
  25. Cambridge, MA 02139, USA.
  26.  
  27. \**********************************************************************/
  28.  
  29. #include "msg graphics.h"
  30. #include "msg menus.h"
  31. #include "msg sounds.h"
  32. #include "msg prefs.h"
  33. #include "msg environment.h"
  34. #include "jotto globals.h"
  35. #include "jotto load-save.h"
  36. #include "jotto.h"
  37.  
  38. Boolean            gMenuEnabled;
  39. MenuHandle        gAppleMenu;
  40. MenuHandle        gFileMenu;
  41. MenuHandle        gEditMenu;
  42. MenuHandle        gOptionsMenu;
  43. MenuHandle        gHelpMenu;
  44.  
  45. extern    long        menuDisable : 0x0b54;
  46.  
  47. void AdjustMenus(void)
  48. {
  49.     WindowPeek    theWindow;
  50.     int            kind;
  51.     int            i;
  52.     
  53.     theWindow = (WindowPeek)FrontWindow();
  54.     kind = theWindow ? theWindow->windowKind : 0;
  55.     
  56.     if(kind < 0)
  57.         EnableItem(gEditMenu, 0);
  58.     else
  59.         DisableItem(gEditMenu, 0);
  60.     
  61.     if(theWindow)
  62.         EnableItem(gFileMenu, closeItem);
  63.     else
  64.         DisableItem(gFileMenu, closeItem);
  65.     
  66.     if (gMainWindow)
  67.     {
  68.         EnableItem(gFileMenu, saveItem);
  69.         EnableItem(gFileMenu, saveAsItem);
  70.         DisableItem(gFileMenu, newItem);
  71.         DisableItem(gFileMenu, openItem);    
  72.         DisableItem(gOptionsMenu, dupToggle);
  73.         DisableItem(gOptionsMenu, nonWordsToggle);
  74.         DisableItem(gOptionsMenu, useFiveLetter);
  75.         DisableItem(gOptionsMenu, useSixLetter);
  76.     }
  77.     else
  78.     {
  79.         DisableItem(gFileMenu, saveItem);
  80.         DisableItem(gFileMenu, saveAsItem);
  81.         EnableItem(gFileMenu, newItem);
  82.         EnableItem(gFileMenu, openItem);
  83.         EnableItem(gOptionsMenu, dupToggle);
  84.         EnableItem(gOptionsMenu, nonWordsToggle);
  85.         if (gFiveLetterOK)
  86.             EnableItem(gOptionsMenu, useFiveLetter);
  87.         else
  88.             DisableItem(gOptionsMenu, useFiveLetter);
  89.         
  90.         if (gSixLetterOK)
  91.             EnableItem(gOptionsMenu, useSixLetter);
  92.         else
  93.             DisableItem(gOptionsMenu, useSixLetter);
  94.     }
  95.     
  96.     CheckItem(gOptionsMenu, dupToggle, gAllowDup);
  97.     CheckItem(gOptionsMenu, nonWordsToggle, gNonWordsCount);
  98.     CheckItem(gOptionsMenu, animationToggle, gAnimation);
  99.     CheckItem(gOptionsMenu, useFiveLetter, (gNumLetters==5));
  100.     CheckItem(gOptionsMenu, useSixLetter, (gNumLetters==6));
  101.     
  102.     CheckItem(gOptionsMenu, soundToggle, gSoundToggle&&gSoundAvailable);
  103.     if (gSoundAvailable)
  104.         EnableItem(gOptionsMenu, soundToggle);
  105.     else
  106.         DisableItem(gOptionsMenu, soundToggle);
  107.     
  108. //    DrawMenuBar();
  109. }
  110.  
  111. void HandleMenu(long mSelect)
  112. {
  113.     int            menuID = HiWord(mSelect);
  114.     int            menuItem = LoWord(mSelect);
  115.     
  116.     if (menuID==0)
  117.     {
  118.         menuID=HiWord(menuDisable);
  119.         menuItem=LoWord(menuDisable);
  120.         gMenuEnabled=FALSE;
  121.     }
  122.     else gMenuEnabled=TRUE;
  123.     menuDisable=0L;
  124.  
  125.     switch (menuID)
  126.     {
  127.         case appleMenu:
  128.             HandleAppleMenu(menuItem);
  129.             break;
  130.         case fileMenu:
  131.             HandleFileMenu(menuItem);
  132.             break;    
  133.         case editMenu:
  134.             HandleEditMenu(menuItem);
  135.             break;
  136.         case optionsMenu:
  137.             HandleOptionsMenu(menuItem);
  138.             break;
  139.         case helpMenu:
  140.             HandleHelpMenu(menuItem);
  141.             break;
  142.       }
  143. }
  144.  
  145. void HandleAppleMenu(int menuItem)
  146. {
  147.     GrafPtr        savePort;
  148.     Str255        name;
  149.     
  150.     if(menuItem == 1)
  151.         ShowInformation();
  152.     if (menuItem == 2)
  153.         ShowSplashScreen();
  154.     else if(menuItem > 3)
  155.     {
  156.         GetPort(&savePort);
  157.         GetItem(gAppleMenu, menuItem, name);
  158.         OpenDeskAcc(name);
  159.         SetPort(savePort);
  160.     }
  161. }
  162.  
  163. void HandleFileMenu(int menuItem)
  164. {
  165.     Point            where;
  166.     SFTypeList        typeList;
  167.     SFReply            reply;
  168.     WindowPtr        theWindow;
  169.     int                i;
  170.     
  171.     switch (menuItem)
  172.     {
  173.         case newItem:
  174.             if (gMenuEnabled)
  175.                 NewGame();
  176.             else DoSound(sound_fluff);
  177.             break;
  178.         case openItem:
  179.             if (gMenuEnabled)
  180.                 LoadSaveDispatch(TRUE, FALSE);
  181.             else DoSound(sound_fluff);
  182.             break;
  183.         case closeItem:
  184.             if (gMenuEnabled)
  185.             {
  186.                 theWindow=FrontWindow();
  187.                 for (i=0; i<NUM_HELP; i++)
  188.                     if (theWindow == gHelp[i])
  189.                         gHelp[i]=0L;
  190.                 
  191.                 if(theWindow == gMainWindow)
  192.                     CloseMainWindow();
  193.                 else
  194.                     DisposeWindow(theWindow);
  195.                 
  196.                 AdjustMenus();
  197.             }
  198.             else DoSound(sound_fluff);
  199.             break;
  200.         case saveItem:
  201.             if (gMenuEnabled)
  202.                 LoadSaveDispatch(FALSE, TRUE);
  203.             else DoSound(sound_fluff);
  204.             break;
  205.         case saveAsItem:
  206.             if (gMenuEnabled)
  207.                 LoadSaveDispatch(FALSE, FALSE);
  208.             else DoSound(sound_fluff);
  209.             break;
  210.         case quitItem:
  211.             gDone = TRUE;
  212.             break;
  213.     }
  214. }
  215.  
  216. void HandleEditMenu(int menuItem)
  217. {
  218.     if ((menuItem>0) && (menuItem!=2))
  219.         if (gMenuEnabled)
  220.         {
  221.             if(!SystemEdit(menuItem - 1))
  222.                 if(menuItem == undoItem)
  223.                     GameUndo();
  224.         }
  225.         else DoSound(sound_fluff);
  226. }
  227.  
  228. void HandleOptionsMenu(int menuItem)
  229. {
  230.     switch (menuItem)
  231.     {
  232.         case dupToggle:
  233.         case nonWordsToggle:
  234.         case useFiveLetter:
  235.         case useSixLetter:
  236.         case animationToggle:
  237.         case soundToggle:
  238.             if (gMenuEnabled)
  239.             {
  240.                 switch (menuItem)
  241.                 {
  242.                     case dupToggle:            gAllowDup=!gAllowDup; break;
  243.                     case nonWordsToggle:    gNonWordsCount=!gNonWordsCount; break;
  244.                     case useFiveLetter:        gNumLetters=0x05; break;
  245.                     case useSixLetter:        gNumLetters=0x06; break;
  246.                     case animationToggle:    gAnimation=!gAnimation; break;
  247.                     case soundToggle:        gSoundToggle=!gSoundToggle; DoSound(sound_on); break;
  248.                 }
  249.                 SaveThePrefs();
  250.             }
  251.             else DoSound(sound_fluff);
  252.     }
  253. }
  254.  
  255. void HandleHelpMenu(int menuItem)
  256. {
  257.     if ((menuItem>0) && (menuItem<=NUM_HELP))
  258.     {
  259.         OpenHelpWindow(menuItem-1);
  260.         SelectWindow(gHelp[menuItem-1]);
  261.     }
  262. }
  263.